package com.jiaying.sync.database;

import com.jiaying.sync.config.SqlServerConfig;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * SQL Server数据库管理器
 * 负责数据库连接池的初始化、配置和管理
 */
public class SqlServerManager {
    private static final Logger logger = LoggerFactory.getLogger(SqlServerManager.class);
    private HikariDataSource dataSource;
    private SqlServerConfig sqlServerConfig;
    
    /**
     * 构造函数
     */
    public SqlServerManager() {
        initialize();
    }
    
    /**
     * 初始化SQL Server连接池
     */
    private void initialize() {
        try {
            // 初始化SQL Server配置
            this.sqlServerConfig = new SqlServerConfig();
            
            // 创建HikariCP配置
            HikariConfig config = new HikariConfig();
            config.setJdbcUrl("jdbc:sqlserver://" + sqlServerConfig.getHost() + ":" + sqlServerConfig.getPort() + 
                             ";databaseName=" + sqlServerConfig.getDatabaseName() + ";encrypt=false");
            config.setUsername(sqlServerConfig.getUsername());
            config.setPassword(sqlServerConfig.getPassword());
            
            // 连接池配置（从配置文件读取）
            config.setMaximumPoolSize(Math.min(sqlServerConfig.getMaxPoolSize(), 50)); // 增加最大连接数到50
            config.setMinimumIdle(Math.min(sqlServerConfig.getMinIdle(), 10)); // 增加最小空闲连接数到10
            config.setConnectionTimeout(sqlServerConfig.getConnectionTimeoutMs());
            config.setIdleTimeout(sqlServerConfig.getIdleTimeoutMs());
            config.setMaxLifetime(sqlServerConfig.getMaxLifetimeMs());
            config.setLeakDetectionThreshold(sqlServerConfig.getLeakDetectionThresholdMs());
            
            // 性能优化配置
            config.setAutoCommit(false); // 手动控制事务提交
            // config.setConnectionInitSql("SET TRANSACTION ISOLATION LEVEL READ_COMMITTED"); // 设置事务隔离级别
            
            // 设置连接池名称
            config.setPoolName("KafkaListenerPool");
            
            // 创建Hikari数据源
            this.dataSource = new HikariDataSource(config);
            
            logger.info("SQL Server连接池初始化成功，最大连接数: {}", config.getMaximumPoolSize());
        } catch (Exception e) {
            logger.error("SQL Server连接池初始化失败: {}", e.getMessage(), e);
        }
    }
    
    /**
     * 测试SQL Server连接
     * @return 连接是否成功
     */
    public boolean testConnection() {
        Connection conn = null;
        try {
            // 从连接池获取连接
            conn = getConnection();
            // 简单查询测试连接
            conn.createStatement().execute("SELECT 1");
            logger.info("SQL Server连接测试成功");
            return true;
        } catch (SQLException e) {
            logger.error("SQL Server连接测试失败: {}", e.getMessage(), e);
            return false;
        } finally {
            // 关闭连接，返回到连接池
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    logger.error("关闭Connection失败: {}", e.getMessage(), e);
                }
            }
        }
    }
    
    /**
     * 从连接池获取连接
     * @return SQL Server连接
     * @throws SQLException
     */
    public Connection getConnection() throws SQLException {
        if (dataSource != null) {
            return dataSource.getConnection();
        } else {
            throw new SQLException("连接池未初始化");
        }
    }
    
    /**
     * 关闭数据库连接池
     */
    public void close() {
        if (dataSource != null) {
            dataSource.close();
            logger.info("SQL Server连接池已关闭");
        }
    }
    
    /**
     * 检查连接池是否已关闭
     * @return 连接池是否已关闭
     */
    public boolean isClosed() {
        return dataSource == null || dataSource.isClosed();
    }
}